home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet internetowy / Przegladarki internetowe / Mozilla Seamonkey 1.0.5 pl / seamonkey-1.0.5.pl-PL.win32.installer.exe / CHATZILLA.XPI / bin / components / chatzilla-service.js
Encoding:
JavaScript  |  2006-09-10  |  17.7 KB  |  534 lines
  1. /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  2.  * ***** BEGIN LICENSE BLOCK *****
  3.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  4.  *
  5.  * The contents of this file are subject to the Mozilla Public License Version
  6.  * 1.1 (the "License"); you may not use this file except in compliance with
  7.  * the License. You may obtain a copy of the License at
  8.  * http://www.mozilla.org/MPL/
  9.  *
  10.  * Software distributed under the License is distributed on an "AS IS" basis,
  11.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12.  * for the specific language governing rights and limitations under the
  13.  * License.
  14.  *
  15.  * The Original Code is mozilla.org code.
  16.  *
  17.  * The Initial Developer of the Original Code is
  18.  * Netscape Communications Corporation.
  19.  * Portions created by the Initial Developer are Copyright (C) 1999
  20.  * the Initial Developer. All Rights Reserved.
  21.  *
  22.  * Contributor(s):
  23.  *   Seth Spitzer <sspitzer@netscape.com>
  24.  *   Robert Ginda <rginda@netscape.com>
  25.  *   Justin Arthur <justinarthur@ieee.org>
  26.  *
  27.  * Alternatively, the contents of this file may be used under the terms of
  28.  * either the GNU General Public License Version 2 or later (the "GPL"), or
  29.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  30.  * in which case the provisions of the GPL or the LGPL are applicable instead
  31.  * of those above. If you wish to allow use of your version of this file only
  32.  * under the terms of either the GPL or the LGPL, and not to allow others to
  33.  * use your version of this file under the terms of the MPL, indicate your
  34.  * decision by deleting the provisions above and replace them with the notice
  35.  * and other provisions required by the GPL or the LGPL. If you do not delete
  36.  * the provisions above, a recipient may use your version of this file under
  37.  * the terms of any one of the MPL, the GPL or the LGPL.
  38.  *
  39.  * ***** END LICENSE BLOCK ***** */
  40.  
  41. /*
  42.  * This file contains the following chatzilla related components:
  43.  * 1. Command line handler service, for responding to the -chat command line
  44.  *    option. (CLineHandler)
  45.  * 2. Content handlers for responding to content of type x-application-irc[s]
  46.  *    (IRCContentHandler)
  47.  * 3. Protocol handler for supplying a channel to the browser when an irc://
  48.  *    or ircs:// link is clicked. (IRCProtocolHandler)
  49.  * 4. A (nearly empty) implementation of nsIChannel for telling the browser
  50.  *    that irc:// links have the content type x-application-irc[s] (BogusChannel)
  51.  */
  52.  
  53. /* components defined in this file */
  54. const CLINE_SERVICE_CONTRACTID =
  55.     "@mozilla.org/commandlinehandler/general-startup;1?type=chat";
  56. const CLINE_SERVICE_CID =
  57.     Components.ID("{38a95514-1dd2-11b2-97e7-9da958640f2c}");
  58. const IRCCONTENT_LISTENER_CONTRACTID =
  59.     "@mozilla.org/uriloader/irc-external-content-listener;1";
  60. const IRCSCONTENT_LISTENER_CONTRACTID =
  61.     "@mozilla.org/uriloader/ircs-external-content-listener;1";
  62. const IRCCONTENT_LISTENER_CID =
  63.     Components.ID("{0e339944-6f43-47e2-a6b5-989b1b5dd84c}");
  64. const IRCSCONTENT_LISTENER_CID =
  65.     Components.ID("{0e339944-6f43-47e2-a6b5-989b1b5dd84d}");
  66. const IRCPROT_HANDLER_CONTRACTID =
  67.     "@mozilla.org/network/protocol;1?name=irc";
  68. const IRCSPROT_HANDLER_CONTRACTID =
  69.     "@mozilla.org/network/protocol;1?name=ircs";
  70. const IRCPROT_HANDLER_CID =
  71.     Components.ID("{f21c35f4-1dd1-11b2-a503-9bf8a539ea39}");
  72. const IRCSPROT_HANDLER_CID =
  73.     Components.ID("{f21c35f4-1dd1-11b2-a503-9bf8a539ea3a}");
  74.  
  75. const IRC_MIMETYPE = "application/x-irc";
  76. const IRCS_MIMETYPE = "application/x-ircs";
  77.  
  78.  
  79. /* components used in this file */
  80. const MEDIATOR_CONTRACTID =
  81.     "@mozilla.org/appshell/window-mediator;1";
  82. const STANDARDURL_CONTRACTID =
  83.     "@mozilla.org/network/standard-url;1";
  84. const IOSERVICE_CONTRACTID =
  85.     "@mozilla.org/network/io-service;1";
  86. const ASS_CONTRACTID =
  87.     "@mozilla.org/appshell/appShellService;1";
  88. const RDFS_CONTRACTID =
  89.     "@mozilla.org/rdf/rdf-service;1";
  90.  
  91. /* interafces used in this file */
  92. const nsIWindowMediator  = Components.interfaces.nsIWindowMediator;
  93. const nsICmdLineHandler  = Components.interfaces.nsICmdLineHandler;
  94. const nsICategoryManager = Components.interfaces.nsICategoryManager;
  95. const nsIURIContentListener = Components.interfaces.nsIURIContentListener;
  96. const nsIURILoader       = Components.interfaces.nsIURILoader;
  97. const nsIProtocolHandler = Components.interfaces.nsIProtocolHandler;
  98. const nsIURI             = Components.interfaces.nsIURI;
  99. const nsIStandardURL     = Components.interfaces.nsIStandardURL;
  100. const nsIChannel         = Components.interfaces.nsIChannel;
  101. const nsIRequest         = Components.interfaces.nsIRequest;
  102. const nsIIOService       = Components.interfaces.nsIIOService;
  103. const nsIAppShellService = Components.interfaces.nsIAppShellService;
  104. const nsISupports        = Components.interfaces.nsISupports;
  105. const nsISupportsWeakReference = Components.interfaces.nsISupportsWeakReference;
  106. const nsIRDFService      = Components.interfaces.nsIRDFService;
  107.  
  108. /* Command Line handler service */
  109. function CLineService()
  110. {}
  111.  
  112. CLineService.prototype.commandLineArgument = "-chat";
  113. CLineService.prototype.prefNameForStartup = "general.startup.chat";
  114. CLineService.prototype.chromeUrlForTask = "chrome://chatzilla/content";
  115. CLineService.prototype.helpText = "Start with an IRC chat client";
  116. CLineService.prototype.handlesArgs = false;
  117. CLineService.prototype.defaultArgs = "";
  118. CLineService.prototype.openWindowWithArgs = false;
  119.  
  120. /* factory for command line handler service (CLineService) */
  121. var CLineFactory = new Object();
  122.  
  123. CLineFactory.createInstance =
  124. function (outer, iid)
  125. {
  126.     if (outer != null)
  127.         throw Components.results.NS_ERROR_NO_AGGREGATION;
  128.  
  129.     if (!iid.equals(nsICmdLineHandler) && !iid.equals(nsISupports))
  130.         throw Components.results.NS_ERROR_INVALID_ARG;
  131.  
  132.     return new CLineService();
  133. }
  134.  
  135. /* content listener */
  136. function IRCContentListener(isSecure)
  137. {
  138.     this.isSecure = isSecure;
  139. }
  140.  
  141. IRCContentListener.prototype.QueryInterface =
  142. function irccl_QueryInterface(iid)
  143. {
  144.     if (!iid.equals(nsIURIContentListener) &&
  145.         !iid.equals(nsISupportsWeakReference) &&
  146.         !iid.equals(nsISupports))
  147.     {
  148.         throw Components.results.NS_ERROR_NO_INTERFACE;
  149.     }
  150.  
  151.     return this;
  152. }
  153.  
  154. IRCContentListener.prototype.loadCookie = null;
  155. IRCContentListener.prototype.parentContentListener = null;
  156.  
  157. IRCContentListener.prototype.onStartURIOpen =
  158. function irccl_onStartURIOpen(uri)
  159. {
  160. }
  161.  
  162. IRCContentListener.prototype.doContent =
  163. function irccl_doContent(contentType, preferred, request, contentHandler, count)
  164. {
  165.     var e;
  166.     var channel = request.QueryInterface(nsIChannel);
  167.  
  168.     var wmClass = Components.classes[MEDIATOR_CONTRACTID];
  169.     var windowManager = wmClass.getService(nsIWindowMediator);
  170.  
  171.     var assClass = Components.classes[ASS_CONTRACTID];
  172.     var ass = assClass.getService(nsIAppShellService);
  173.     hiddenWin = ass.hiddenDOMWindow;
  174.  
  175.     // Ok, not starting currently, so check if we've got existing windows.
  176.     var w = windowManager.getMostRecentWindow("irc:chatzilla");
  177.  
  178.     // Claiming that a ChatZilla window is loading.
  179.     if ("ChatZillaStarting" in hiddenWin)
  180.     {
  181.         dump("cz-service: ChatZilla claiming to be starting.\n");
  182.         if (w && ("client" in w) && ("initialized" in w.client) &&
  183.             w.client.initialized)
  184.         {
  185.             dump("cz-service: It lied. It's finished starting.\n");
  186.             // It's actually loaded ok.
  187.             delete hiddenWin.ChatZillaStarting;
  188.         }
  189.     }
  190.  
  191.     if ("ChatZillaStarting" in hiddenWin)
  192.     {
  193.         count = count || 0;
  194.  
  195.         if ((new Date() - hiddenWin.ChatZillaStarting) > 10000)
  196.         {
  197.             dump("cz-service: Continuing to be unable to talk to existing window!\n");
  198.         }
  199.         else
  200.         {
  201.             //dump("cz-service: **** Try: " + count + ", delay: " + (new Date() - hiddenWin.ChatZillaStarting) + "\n");
  202.  
  203.             // We have a ChatZilla window, but we're still loading.
  204.             hiddenWin.setTimeout(function wrapper(t, count) {
  205.                     t.doContent(contentType, preferred, request, contentHandler, count + 1);
  206.                 }, 250, this, count);
  207.             return true;
  208.         }
  209.     }
  210.  
  211.     // We have a window.
  212.     if (w)
  213.     {
  214.         dump("cz-service: Existing, fully loaded window. Using.\n");
  215.         // Window is working and initialized ok. Use it.
  216.         w.focus();
  217.         w.gotoIRCURL(channel.URI.spec);
  218.         return true;
  219.     }
  220.  
  221.     dump("cz-service: No windows, starting new one.\n");
  222.     // Ok, no available window, loading or otherwise, so start ChatZilla.
  223.     var args = new Object();
  224.     args.url = channel.URI.spec;
  225.  
  226.     hiddenWin.ChatZillaStarting = new Date();
  227.     hiddenWin.openDialog("chrome://chatzilla/content/chatzilla.xul", "_blank",
  228.                  "chrome,menubar,toolbar,status,resizable,dialog=no",
  229.                  args);
  230.  
  231.     return true;
  232. }
  233.  
  234. IRCContentListener.prototype.isPreferred =
  235. function irccl_isPreferred(contentType, desiredContentType)
  236. {
  237.     return (contentType == (this.isSecure ? IRCS_MIMETYPE : IRC_MIMETYPE));
  238. }
  239.  
  240. IRCContentListener.prototype.canHandleContent =
  241. function irccl_canHandleContent(contentType, isContentPreferred, desiredContentType)
  242. {
  243.     return (contentType == (this.isSecure ? IRCS_MIMETYPE : IRC_MIMETYPE));
  244. }
  245.  
  246. /* protocol handler factory object (IRCContentListener) */
  247. var IRCContentListenerFactory = new Object();
  248.  
  249. IRCContentListenerFactory.createInstance =
  250. function ircclf_createInstance(outer, iid)
  251. {
  252.     if (outer != null)
  253.         throw Components.results.NS_ERROR_NO_AGGREGATION;
  254.  
  255.     if (!iid.equals(nsIURIContentListener) &&
  256.         !iid.equals(nsISupportsWeakReference) &&
  257.         !iid.equals(nsISupports))
  258.     {
  259.         throw Components.results.NS_ERROR_INVALID_ARG;
  260.     }
  261.  
  262.     return new IRCContentListener(false);
  263. }
  264.  
  265. /* secure protocol handler factory object (IRCContentListener) */
  266. var IRCSContentListenerFactory = new Object();
  267.  
  268. IRCSContentListenerFactory.createInstance =
  269. function ircclf_createInstance(outer, iid)
  270. {
  271.     if (outer != null)
  272.         throw Components.results.NS_ERROR_NO_AGGREGATION;
  273.  
  274.     if (!iid.equals(nsIURIContentListener) &&
  275.         !iid.equals(nsISupportsWeakReference) &&
  276.         !iid.equals(nsISupports))
  277.     {
  278.         throw Components.results.NS_ERROR_INVALID_ARG;
  279.     }
  280.  
  281.     return new IRCContentListener(true);
  282. }
  283.  
  284. /* irc protocol handler component */
  285. function IRCProtocolHandler(isSecure)
  286. {
  287.     this.isSecure = isSecure;
  288. }
  289.  
  290. IRCProtocolHandler.prototype.protocolFlags =
  291.                    nsIProtocolHandler.URI_NORELATIVE |
  292.                    nsIProtocolHandler.ALLOWS_PROXY;
  293.  
  294. IRCProtocolHandler.prototype.allowPort =
  295. function ircph_allowPort(port, scheme)
  296. {
  297.     return false;
  298. }
  299.  
  300. IRCProtocolHandler.prototype.newURI =
  301. function ircph_newURI(spec, charset, baseURI)
  302. {
  303.     var cls = Components.classes[STANDARDURL_CONTRACTID];
  304.     var url = cls.createInstance(nsIStandardURL);
  305.     url.init(nsIStandardURL.URLTYPE_STANDARD, (this.isSecure ? 9999 : 6667), spec, charset, baseURI);
  306.  
  307.     return url.QueryInterface(nsIURI);
  308. }
  309.  
  310. IRCProtocolHandler.prototype.newChannel =
  311. function ircph_newChannel(URI)
  312. {
  313.     ios = Components.classes[IOSERVICE_CONTRACTID].getService(nsIIOService);
  314.     if (!ios.allowPort(URI.port, URI.scheme))
  315.         throw Components.results.NS_ERROR_FAILURE;
  316.  
  317.     var bogusChan = new BogusChannel(URI, this.isSecure);
  318.     bogusChan.contentType = (this.isSecure ? IRCS_MIMETYPE : IRC_MIMETYPE);
  319.     return bogusChan;
  320. }
  321.  
  322. /* protocol handler factory object (IRCProtocolHandler) */
  323. var IRCProtocolHandlerFactory = new Object();
  324.  
  325. IRCProtocolHandlerFactory.createInstance =
  326. function ircphf_createInstance(outer, iid)
  327. {
  328.     if (outer != null)
  329.         throw Components.results.NS_ERROR_NO_AGGREGATION;
  330.  
  331.     if (!iid.equals(nsIProtocolHandler) && !iid.equals(nsISupports))
  332.         throw Components.results.NS_ERROR_INVALID_ARG;
  333.  
  334.     var protHandler = new IRCProtocolHandler(false);
  335.     protHandler.scheme = "irc";
  336.     protHandler.defaultPort = 6667;
  337.     return protHandler;
  338. }
  339.  
  340. /* secure protocol handler factory object (IRCProtocolHandler) */
  341. var IRCSProtocolHandlerFactory = new Object();
  342.  
  343. IRCSProtocolHandlerFactory.createInstance =
  344. function ircphf_createInstance(outer, iid)
  345. {
  346.     if (outer != null)
  347.         throw Components.results.NS_ERROR_NO_AGGREGATION;
  348.  
  349.     if (!iid.equals(nsIProtocolHandler) && !iid.equals(nsISupports))
  350.         throw Components.results.NS_ERROR_INVALID_ARG;
  351.  
  352.     var protHandler = new IRCProtocolHandler(true);
  353.     protHandler.scheme = "ircs";
  354.     protHandler.defaultPort = 9999;
  355.     return protHandler;
  356. }
  357.  
  358. /* bogus IRC channel used by the IRCProtocolHandler */
  359. function BogusChannel(URI, isSecure)
  360. {
  361.     this.URI = URI;
  362.     this.originalURI = URI;
  363.     this.isSecure = isSecure;
  364. }
  365.  
  366. BogusChannel.prototype.QueryInterface =
  367. function bc_QueryInterface(iid)
  368. {
  369.     if (!iid.equals(nsIChannel) && !iid.equals(nsIRequest) &&
  370.         !iid.equals(nsISupports))
  371.         throw Components.results.NS_ERROR_NO_INTERFACE;
  372.  
  373.     return this;
  374. }
  375.  
  376. /* nsIChannel */
  377. BogusChannel.prototype.loadAttributes = null;
  378. BogusChannel.prototype.contentLength = 0;
  379. BogusChannel.prototype.owner = null;
  380. BogusChannel.prototype.loadGroup = null;
  381. BogusChannel.prototype.notificationCallbacks = null;
  382. BogusChannel.prototype.securityInfo = null;
  383.  
  384. BogusChannel.prototype.open =
  385. function bc_open()
  386. {
  387.     throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
  388. }
  389.  
  390. BogusChannel.prototype.asyncOpen =
  391. function bc_asyncOpen(observer, ctxt)
  392. {
  393.     observer.onStartRequest(this, ctxt);
  394. }
  395.  
  396. BogusChannel.prototype.asyncRead =
  397. function bc_asyncRead(listener, ctxt)
  398. {
  399.     return listener.onStartRequest(this, ctxt);
  400. }
  401.  
  402. /* nsIRequest */
  403. BogusChannel.prototype.isPending =
  404. function bc_isPending()
  405. {
  406.     return true;
  407. }
  408.  
  409. BogusChannel.prototype.status = Components.results.NS_OK;
  410.  
  411. BogusChannel.prototype.cancel =
  412. function bc_cancel(status)
  413. {
  414.     this.status = status;
  415. }
  416.  
  417. BogusChannel.prototype.suspend =
  418. BogusChannel.prototype.resume =
  419. function bc_suspres()
  420. {
  421.     throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
  422. }
  423.  
  424. var ChatzillaModule = new Object();
  425.  
  426. ChatzillaModule.registerSelf =
  427. function cz_mod_registerSelf(compMgr, fileSpec, location, type)
  428. {
  429.     compMgr = compMgr.QueryInterface(Components.interfaces.nsIComponentRegistrar);
  430.     var catman = Components.classes["@mozilla.org/categorymanager;1"]
  431.         .getService(nsICategoryManager);
  432.  
  433.     debug("*** Registering -chat handler.\n");
  434.     compMgr.registerFactoryLocation(CLINE_SERVICE_CID,
  435.                                     "Chatzilla CommandLine Service",
  436.                                     CLINE_SERVICE_CONTRACTID,
  437.                                     fileSpec, location, type);
  438.     catman.addCategoryEntry("command-line-argument-handlers",
  439.                             "chatzilla command line handler",
  440.                             CLINE_SERVICE_CONTRACTID, true, true);
  441.  
  442.     debug("*** Registering content listener.\n");
  443.     compMgr.registerFactoryLocation(IRCCONTENT_LISTENER_CID,
  444.                                     "IRC content listener",
  445.                                     IRCCONTENT_LISTENER_CONTRACTID,
  446.                                     fileSpec, location, type);
  447.     catman.addCategoryEntry("external-uricontentlisteners",
  448.                             IRC_MIMETYPE,
  449.                             IRCCONTENT_LISTENER_CONTRACTID, true, true);
  450.  
  451.     debug("*** Registering secure content listener.\n");
  452.     compMgr.registerFactoryLocation(IRCSCONTENT_LISTENER_CID,
  453.                                     "IRC content listener",
  454.                                     IRCSCONTENT_LISTENER_CONTRACTID,
  455.                                     fileSpec, location, type);
  456.     catman.addCategoryEntry("external-uricontentlisteners",
  457.                             IRCS_MIMETYPE,
  458.                             IRCSCONTENT_LISTENER_CONTRACTID, true, true);
  459.  
  460.     debug("*** Registering irc protocol handler.\n");
  461.     compMgr.registerFactoryLocation(IRCPROT_HANDLER_CID,
  462.                                     "IRC protocol handler",
  463.                                     IRCPROT_HANDLER_CONTRACTID,
  464.                                     fileSpec, location, type);
  465.  
  466.     debug("*** Registering ircs protocol handler.\n");
  467.     compMgr.registerFactoryLocation(IRCSPROT_HANDLER_CID,
  468.                                     "IRCS protocol handler",
  469.                                     IRCSPROT_HANDLER_CONTRACTID,
  470.                                     fileSpec, location, type);
  471.  
  472.     debug("*** Registering done.\n");
  473. }
  474.  
  475. ChatzillaModule.unregisterSelf =
  476. function cz_mod_unregisterSelf(compMgr, fileSpec, location)
  477. {
  478.     compMgr = compMgr.QueryInterface(Components.interfaces.nsIComponentRegistrar);
  479.  
  480.     var catman = Components.classes["@mozilla.org/categorymanager;1"]
  481.         .getService(nsICategoryManager);
  482.     catman.deleteCategoryEntry("command-line-argument-handlers",
  483.                                CLINE_SERVICE_CONTRACTID, true);
  484. }
  485.  
  486. ChatzillaModule.getClassObject =
  487. function cz_mod_getClassObject(compMgr, cid, iid)
  488. {
  489.     // Checking if we're disabled in the Chrome Registry.
  490.     var rv;
  491.     try {
  492.         var rdfSvc = Components.classes[RDFS_CONTRACTID].getService(nsIRDFService);
  493.         var rdfDS = rdfSvc.GetDataSource("rdf:chrome");
  494.         var resSelf = rdfSvc.GetResource("urn:mozilla:package:chatzilla");
  495.         var resDisabled = rdfSvc.GetResource("http://www.mozilla.org/rdf/chrome#disabled");
  496.         rv = rdfDS.GetTarget(resSelf, resDisabled, true);
  497.     } catch (e) {
  498.     }
  499.     if (rv)
  500.         throw Components.results.NS_ERROR_NO_INTERFACE;
  501.  
  502.     if (cid.equals(CLINE_SERVICE_CID))
  503.         return CLineFactory;
  504.  
  505.     if (cid.equals(IRCCONTENT_LISTENER_CID))
  506.         return IRCContentListenerFactory;
  507.  
  508.     if (cid.equals(IRCSCONTENT_LISTENER_CID))
  509.         return IRCSContentListenerFactory;
  510.  
  511.     if (cid.equals(IRCPROT_HANDLER_CID))
  512.         return IRCProtocolHandlerFactory;
  513.  
  514.     if (cid.equals(IRCSPROT_HANDLER_CID))
  515.         return IRCSProtocolHandlerFactory;
  516.  
  517.     if (!iid.equals(Components.interfaces.nsIFactory))
  518.         throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
  519.  
  520.     throw Components.results.NS_ERROR_NO_INTERFACE;
  521. }
  522.  
  523. ChatzillaModule.canUnload =
  524. function cz_mod_canUnload(compMgr)
  525. {
  526.     return true;
  527. }
  528.  
  529. /* entrypoint */
  530. function NSGetModule(compMgr, fileSpec)
  531. {
  532.     return ChatzillaModule;
  533. }
  534.